﻿#define _CRT_SECURE_NO_WARNINGS 1
//给你一个由不同字符组成的字符串 allowed 和一个字符串数组 words 。如果一个字符串的每一个字符都在 allowed 中，就称这个字符串是 一致字符串 。
//
//请你返回 words 数组中 一致字符串 的数目。
//
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/count-the-number-of-consistent-strings
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int countConsistentStrings(char * allowed, char ** words, int wordsSize){
//	int a[26] = { 0 };
//	int i, j = 0;
//	int b = 0;
//	for (i = 0; allowed[i] != 0; i++)
//	{
//		a[allowed[i] - 'a']++;
//	}
//	for (i = 0; i<wordsSize; i++)
//	{
//		for (j = 0; words[i][j] != '\0'; j++)
//		{
//			if (a[words[i][j] - 'a'] == 0)
//			{
//				break;
//			}
//		}
//		if (words[i][j] == '\0')
//		{
//			b++;
//		}
//	}
//	return b;
//}







///**给你两个整数数组 nums 和 index。你需要按照以下规则创建目标数组：
//
//目标数组 target 最初为空。
//按从左到右的顺序依次读取 nums[i] 和 index[i]，在 target 数组中的下标 index[i] 处插入值 nums[i] 。
//重复上一步，直到在 nums 和 index 中都没有要读取的元素。
//请你返回目标数组。
//
//题目保证数字插入位置总是存在。
//
//来源：力扣（LeetCode）
//链接：https://leetcode-cn.com/problems/create-target-array-in-the-given-order
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//* Note: The returned array must be malloced, assume caller calls free().
//*/
//int* createTargetArray(int* nums, int numsSize, int* index, int indexSize, int* returnSize){
//	int i, j = 0;
//	int* a = (int*)malloc((numsSize + 1)*sizeof(int));
//	*returnSize = numsSize;
//	for (i = 0; i<numsSize; i++)
//	{
//		if (i == index[i])
//		{
//			a[index[i]] = nums[i];
//		}
//		else
//		{
//			for (j = i + 1; j>index[i]; j--)
//			{
//				a[j] = a[j - 1];
//			}
//			a[index[i]] = nums[i];
//		}
//	}
//	return a;
//}








/**给你一个数组 nums，对于其中每个元素 nums[i]，请你统计数组中比它小的所有数字的数目。

换而言之，对于每个 nums[i] 你必须计算出有效的 j 的数量，其中 j 满足 j != i 且 nums[j] < nums[i] 。

以数组形式返回答案。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/how-many-numbers-are-smaller-than-the-current-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
* Note: The returned array must be malloced, assume caller calls free().
*/
//int* smallerNumbersThanCurrent(int* nums, int numsSize, int* returnSize){
//	int i = 0;
//	int j = 0;
//	int count = 0;
//	int*a = (int*)malloc(numsSize*sizeof(nums));
//	*returnSize = numsSize;
//	for (i = 0; i<numsSize; i++)
//	{
//		count = 0;
//		for (j = 0; j<numsSize; j++)
//		{
//			if (nums[i]>nums[j] && i != j)
//			{
//				count++;
//			}
//		}
//		a[i] = count;
//	}
//	return a;
//}
//
//
//
//
//
//
//
//全字母句 指包含英语字母表中每个字母至少一次的句子。
//给你一个仅由小写英文字母组成的字符串 sentence ，请你判断 sentence 是否为 全字母句 。
//如果是，返回 true ；否则，返回 false 。
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/check-if-the-sentence-is-pangram
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//bool checkIfPangram(char * sentence){
//	int i = 0;
//	int j = 0;
//	int a[26] = { 0 };
//	int len = strlen(sentence);
//	for (i = 0; i<len; i++)
//	{
//		j = sentence[i] - 'a';
//		a[j]++;
//	}
//	for (i = 0; i<26; i++)
//	{
//		if (a[i] == 0)
//		{
//			return 0;
//		}
//	}
//	return 1;
//}
//
//
//
//
//
//
//
//
//
//已知函数 signFunc(x) 将会根据 x 的正负返回特定值：
//如果 x 是正数，返回 1 。
//如果 x 是负数，返回 - 1 。
//如果 x 是等于 0 ，返回 0 。
//给你一个整数数组 nums 。令 product 为数组 nums 中所有元素值的乘积。
//返回 signFunc(product) 。
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/sign-of-the-product-of-an-array
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int arraySign(int* nums, int numsSize){
//	int count = 1;
//	int i = 0;
//	for (i = 0; i<numsSize; i++)
//	{
//		if (nums[i]<0)
//		{
//			count *= -1;
//		}
//		if (nums[i] == 0)
//		{
//			return 0;
//		}
//	}
//	return count;
//}
//
//
//
//
//
//
//
//
//给你一个非负整数 num ，请你返回将它变成 0 所需要的步数。 
//如果当前数字是偶数，你需要把它除以 2 ；否则，减去 1 。
//int numberOfSteps(int num){
//	int count = 0;
//	while (num)
//	{
//		if (num % 2 == 0)
//		{
//			num /= 2;
//		}
//		else
//		{
//			num -= 1;
//		}
//		count++;
//	}
//	return count;
//}
//
//
//
//
//
//
//
//
//给你一个二维整数数组 logs ，其中每个 logs[i] = [birthi, deathi] 表示第 i 个人的出生和死亡年份。
//年份 x 的 人口 定义为这一年期间活着的人的数目。
//第 i 个人被计入年份 x 的人口需要满足：x 在闭区间[birthi, deathi - 1] 内。注意，人不应当计入他们死亡当年的人口中。
//返回 人口最多 且 最早 的年份。
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/maximum-population-year
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int maximumPopulation(int** logs, int logsSize, int* logsColSize){
//	int a[100] = { 0 };
//	int i = 0;
//	int j = 0;
//	int k = 0;
//	for (i = 0; i<logsSize; i++)
//	{
//		for (j = logs[i][0] - 1950; j<logs[i][1] - 1950; j++)
//		{
//			a[j]++;
//		}
//	}
//	for (i = 0; i<100; i++)
//	{
//		if (a[i]>a[k])
//		{
//			k = i;
//		}
//	}
//	k += 1950;
//	return k;
//}